Application software has typically been written to be executed on a single computer system. However with increasing complexity of technology products, such as integrated circuits, computational demands in product design have also increased. Execution of application software to design a complex product using a single computer system may take quite some time.
Multi-threading has been used by application software to utilize more than one processor in a single computer system to speed execution time. With multi-threading, a single copy of an application program is run on multiple processors using shared memory with different threads of execution. It is impractical to share a fast memory space across a network to execute an application. Thus with multi-threading using a shared memory model, computational transactions of the application program cannot be readily distributed to other computer systems across a network.
Moreover with multi-threading, the application software program needs to be thread safe. For most legacy software applications of reasonable complexity, it is difficult if not impossible to make previously written software to be thread-safe. Even if the issue of thread-safety is adequately addressed, multithreaded application software may still also experience thread deadlocks. Thread deadlocks may occur when two or more threads are competing for the same resource, such as memory space. Thread deadlocks can vary based on the machine type, speed, operating system etc. Due to the temporal nature of thread deadlocks, they can be extremely hard to debug. This makes multi-threaded application software difficult to maintain/fix when bugs are encountered. Additionally, software bugs in multi-threaded programs are very hard to debug since the behavior of multi-threaded software in the debugger is inherently different from its behavior in a real-time environment.
Moreover, multi-threading software techniques do not lend themselves well to scaling since the number of threads that can be run is limited by the number of processors (e.g., 2-10) on a single machine which is typically less than the number of total processors available (e.g., 100-10000) in a large organization.
New application software may be written from scratch for utilizing multi-processing across a distributed computer network. However, legacy application software requires a substantially complete software rewrite to utilize multi-processing software techniques. A complete software rewrite of legacy application software for multiple processing is a time-consuming process and may be unrealistic given time and budget constraints. The resources required to achieve a substantially complete software rewrite of legacy application software may not be economically viable.